Git Hooks e Automação

Descubra como usar os Git Hooks para automatizar seus processos de desenvolvimento.

Git Hooks Básicos

Configuração

# Ativar os hooks
git config core.hooksPath .git/hooks

# Criar um hook pre-commit
touch .git/hooks/pre-commit
chmod +x .git/hooks/pre-commit

Hooks Comuns

# pre-commit
#!/bin/sh
# Executado antes de cada commit
echo "Vérification du code..."

# post-commit
#!/bin/sh
# Executado após cada commit
echo "Notification envoyée..."

# pre-push
#!/bin/sh
# Executado antes de cada push
echo "Tests en cours..."

# post-merge
#!/bin/sh
# Executado após cada merge
echo "Mise à jour des dépendances..."

Exemplos Práticos

Verificação do Código

# pre-commit
#!/bin/sh

# Verificar a formatação
echo "Vérification du formatage..."
npm run lint

# Executar os testes
echo "Exécution des tests..."
npm test

# Verificar os tipos
echo "Vérification des types..."
npm run type-check

Validação das Mensagens

# commit-msg
#!/bin/sh

# Verificar o formato da mensagem
commit_msg=$(cat "$1")
if ! echo "$commit_msg" | grep -qE "^(feat|fix|docs|style|refactor|test|chore)(\(.+\))?: .+"; then
    echo "Format de message invalide"
    echo "Utilisez: type(scope): description"
    exit 1
fi

Deploy Automático

# post-push
#!/bin/sh

# Fazer deploy em staging
if [ "$(git rev-parse --abbrev-ref HEAD)" = "develop" ]; then
    echo "Déploiement en staging..."
    npm run deploy:staging
fi

# Fazer deploy em produção
if [ "$(git rev-parse --abbrev-ref HEAD)" = "main" ]; then
    echo "Déploiement en production..."
    npm run deploy:prod
fi

Husky para Node.js

Instalação

# Instalar o Husky
npm install husky --save-dev

# Inicializar o Husky
npx husky install

# Adicionar um hook
npx husky add .husky/pre-commit "npm test"

Configuração

// package.json
{
  "scripts": {
    "prepare": "husky install"
  },
  "husky": {
    "hooks": {
      "pre-commit": "npm test",
      "commit-msg": "commitlint -E HUSKY_GIT_PARAMS"
    }
  }
}

Git Hooks com Python

Exemplo de Hook

#!/usr/bin/env python3
# pre-commit

import sys
import subprocess

def run_tests():
    try:
        subprocess.run(['pytest'], check=True)
    except subprocess.CalledProcessError:
        print("Les tests ont échoué")
        sys.exit(1)

def check_formatting():
    try:
        subprocess.run(['black', '--check', '.'], check=True)
    except subprocess.CalledProcessError:
        print("Le formatage est incorrect")
        sys.exit(1)

if __name__ == '__main__':
    run_tests()
    check_formatting()

Integração Contínua

GitHub Actions

# .github/workflows/ci.yml
name: CI

on:
  push:
    branches: [ main ]
  pull_request:
    branches: [ main ]

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v2
    - name: Install dependencies
      run: npm install
    - name: Run tests
      run: npm test
    - name: Check formatting
      run: npm run lint

GitLab CI

# .gitlab-ci.yml
stages:
  - test
  - deploy

test:
  stage: test
  script:
    - npm install
    - npm test
    - npm run lint

deploy:
  stage: deploy
  script:
    - npm run deploy
  only:
    - main

Boas Práticas

1. Segurança

   • Verificar as dependências
   • Escanear o código
   • Validar os segredos
   • Proteger as branches

2. Desempenho

   • Hooks leves
   • Testes rápidos
   • Cache dos resultados
   • Paralelização

3. Manutenção

   • Documentação clara
   • Testes dos hooks
   • Tratamento de erros
   • Logs detalhados

Conclusão

Pontos-chave a lembrar:

• Automação dos processos
• Validação do código
• Deploy automático
• Integração contínua

Recomendações:

• Escolher os hooks certos
• Automatizar os testes
• Proteger os processos
• Seguir as boas práticas
• Aprofundar-se em Git