Guia: Automatize o versionamento com Git e Python

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

Perguntas comuns sobre como automatizar o versionamento com Git e Python

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 sys.argv em Python ou $1 em um script de shell.
7. Qual comando recupera o hash de commit mais recente do Git?
8. O comando git rev-parse HEAD 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 git add 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.