Guia: Automatize o versionamento com Git e Python

Lucas Simon
Segunda-feira, 20 de maio de 2024 às 09:24:56
Python Script

Criando um sistema de versionamento com Git e Python

Automatizar o controle de versão dos arquivos do seu projeto é crucial para manter um fluxo de trabalho de desenvolvimento organizado e eficiente. Usando Git e Python, você pode criar um sistema que atualiza um arquivo version.py a cada commit. Isso garante que a versão do seu projeto seja sempre precisa e reflita as alterações mais recentes feitas na sua base de código.

Neste guia, exploraremos um método para atualizar automaticamente um arquivo version.py a cada envio para seu repositório Git. Discutiremos a implementação de um script que captura detalhes de commit, incrementa o número da versão e se integra perfeitamente ao seu fluxo de trabalho Git.

Automatizando o versionamento em Python usando Git Hooks

Script Python para gancho pré-push

#!/usr/bin/env /usr/bin/python
import os
import subprocess
import re
import sys

commit_msg_file = sys.argv[1]
with open(commit_msg_file, 'r') as file:
    commit_msg = file.read().strip()

version_file = os.path.abspath('version.py')
hashed_code = subprocess.check_output(['git', 'rev-parse', 'HEAD']).strip().decode('utf-8')

if os.path.exists(version_file):
    print(f'Reading previous {version_file}')
    with open(version_file, 'r') as f:
        content = f.read()
        major, minor, patch = map(int, re.search(r'version = "(\d+)\.(\d+)\.(\d+)"', content).groups())
    patch += 1
else:
    print(f'Creating new {version_file}')
    major, minor, patch = 0, 0, 1

print(f'Writing contents of {version_file} with "{commit_msg}"')
with open(version_file, 'w') as f:
    f.write(f'''# This file is created by the pre-push script
class Version:
    comment = "{commit_msg}"
    hash = "{hashed_code}"
    version = "{major}.{minor}.{patch}"

if __name__ == "__main__":
    print(Version.version)
''')

subprocess.call(['git', 'add', version_file])

Configurando o Git Hook para incremento de versão

Script Git Hook no Shell

#!/bin/sh

VERSION_PY="version.py"

# Get the commit message file from the arguments
COMMIT_MSG_FILE=$1

# Extract the commit message
COMMIT_MSG=$(cat $COMMIT_MSG_FILE)

# Get the latest commit hash
GIT_HASH=$(git rev-parse HEAD)

if [ -f "$VERSION_PY" ]; then
  VERSION=$(grep -oP '(?<=version = ")(\d+\.\d+\.\d+)' $VERSION_PY)
  IFS='.' read -r -a VERSION_PARTS <<< "$VERSION"
  VERSION_PARTS[2]=$((VERSION_PARTS[2] + 1))
  NEW_VERSION="${VERSION_PARTS[0]}.${VERSION_PARTS[1]}.${VERSION_PARTS[2]}"
else
  NEW_VERSION="0.0.1"
fi

echo "# This file is created by the pre-push script" > $VERSION_PY
echo "class Version:" >> $VERSION_PY
echo "    comment = \"$COMMIT_MSG\"" >> $VERSION_PY
echo "    hash = \"$GIT_HASH\"" >> $VERSION_PY
echo "    version = \"$NEW_VERSION\"" >> $VERSION_PY

git add $VERSION_PY

Aprimorando o fluxo de trabalho do Git com controle de versão automatizado

Automatizar o controle de versão em um fluxo de trabalho Git não apenas garante consistência, mas também melhora a rastreabilidade em projetos de software. Ao integrar o gerenciamento de versões diretamente nos ganchos do Git, os desenvolvedores podem manter um processo contínuo e eficiente. Uma abordagem é usar o gancho pré-push do Git para atualizar automaticamente um arquivo de versão a cada commit. Este método envolve a captura de mensagens de commit e valores hash, que são essenciais para rastrear alterações e manter um registro histórico da base de código.

Outro aspecto crucial é a capacidade de reverter as alterações com precisão. Com um arquivo de versão atualizado, os desenvolvedores podem identificar o estado exato do projeto em qualquer versão. Isso é particularmente útil em ambientes de integração e implantação contínuas (CI/CD), onde a automação é fundamental. Garantir que o arquivo de versão seja atualizado de forma confiável a cada confirmação ajuda a manter um pipeline de implantação robusto, reduzindo erros manuais e simplificando os lançamentos.

  1. Como posso automatizar o versionamento em meu repositório Git?
  2. Você pode automatizar o controle de versão usando ganchos Git, como o gancho pré-push, e scripts para atualizar um arquivo de versão em cada confirmação.
  3. O que é um gancho pré-empurrado?
  4. Um gancho pré-push é um gancho Git que executa scripts antes que as alterações sejam enviadas para um repositório remoto. Ele pode ser usado para automatizar tarefas como atualizar um arquivo de versão.
  5. Como acesso a mensagem de commit em um script de gancho do Git?
  6. Você pode acessar a mensagem de commit lendo o arquivo passado como argumento para o script, normalmente usando em Python ou em um script de shell.
  7. Qual comando recupera o hash de commit mais recente do Git?
  8. O comando recupera o hash de commit mais recente em um repositório Git.
  9. Como incremento o número da versão em um script?
  10. Use expressões regulares para extrair a versão atual, incrementar o número do patch e reescrever o arquivo de versão com o novo número de versão.
  11. Posso usar este método com ferramentas de integração contínua?
  12. Sim, a automação do controle de versão com ganchos Git pode ser integrada aos pipelines de CI/CD para garantir a consistência da versão em compilações e implantações.
  13. Quais são os benefícios do versionamento automatizado?
  14. O controle de versão automatizado reduz erros manuais, garante rastreamento de versão consistente e agiliza o processo de desenvolvimento e implantação.
  15. Como posso garantir que o arquivo da versão seja incluído no próximo commit?
  16. Usar para preparar o arquivo de versão após ele ter sido atualizado pelo script.
  17. O que acontece se o arquivo da versão não existir?
  18. Se o arquivo de versão não existir, o script poderá criá-lo com um número de versão inicial, como 0.0.1.
  19. É possível usar outras linguagens de programação para ganchos Git?
  20. Sim, você pode escrever scripts de gancho Git em várias linguagens de programação, como Python, Bash ou Perl, dependendo de sua preferência e dos requisitos do projeto.

Considerações finais sobre versionamento automatizado

Automatizar a atualização de um arquivo version.py com cada push do Git é uma solução prática para manter um controle de versão preciso em seus projetos. Os scripts fornecidos utilizam ganchos Git e Python para automatizar esse processo, garantindo que cada commit seja rastreado com um número de versão atualizado, mensagem de commit e hash. A implementação deste método pode melhorar muito o seu fluxo de trabalho, tornando-o mais eficiente e reduzindo as chances de erro humano. Seguindo as diretrizes e exemplos fornecidos, você pode integrar facilmente o controle de versão automatizado em suas próprias práticas de desenvolvimento.