Automatiser les vérifications de code avec les hooks pre-commit de Git

Tous les développeurs connaissent la frustration de pousser du code pour voir ensuite les pipelines CI/CD échouer à cause de problèmes de formatage ou d’erreurs de linting. Et si vous pouviez détecter ces problèmes avant même qu’ils n’atteignent votre dépôt ? Les hooks pre-commit de Git offrent une solution puissante qui exécute des vérifications automatisées localement, permettant d’économiser du temps et de maintenir une qualité de code cohérente au sein de votre équipe.

Cet article vous guide dans la configuration des hooks pre-commit de git en utilisant le framework pre-commit, la configuration d’outils essentiels comme ESLint, Prettier et Black, et l’implémentation de bonnes pratiques qui maintiennent votre flux de développement fluide et efficace.

Que sont les hooks pre-commit de Git ?

Les hooks Git sont des scripts que Git exécute avant ou après des événements tels que commit, push et receive. Un hook pre-commit de git s’exécute spécifiquement après que vous ayez mis en stage vos modifications mais avant que Git ne crée le commit. Si le hook se termine avec un statut non-zéro, Git annule le commit, vous donnant une chance de corriger les problèmes en premier.

Bien que vous puissiez écrire des hooks sous forme de simples scripts shell dans .git/hooks/, leur gestion devient complexe à mesure que votre projet grandit. C’est là que le framework pre-commit excelle—il fournit une façon standardisée de gérer et partager les hooks au sein de votre équipe.

Pourquoi utiliser le framework pre-commit ?

Le framework pre-commit résout plusieurs points douloureux des hooks Git natifs :

• Installation et mises à jour faciles : Les hooks sont versionnés et installés via une simple configuration YAML
• Agnostique au langage : Exécutez des linters Python, des formateurs JavaScript et des scripts shell depuis une seule configuration
• Exécution sélective : Les hooks s’exécutent uniquement sur les fichiers modifiés, gardant les commits rapides
• Cohérence d’équipe : Partagez le même fichier .pre-commit-config.yaml dans toute votre équipe

Configuration de pre-commit dans votre projet

D’abord, installez le package pre-commit :

pip install pre-commit

Créez un fichier .pre-commit-config.yaml à la racine de votre projet. Voici une configuration pratique qui couvre les besoins courants :

repos:
  # Basic file fixes
  - repo: https://github.com/pre-commit/pre-commit-hooks
    rev: v4.5.0
    hooks:
      - id: trailing-whitespace
      - id: end-of-file-fixer
      - id: check-yaml
      - id: check-added-large-files

  # Python formatting with Black
  - repo: https://github.com/psf/black
    rev: 24.2.0
    hooks:
      - id: black
        files: \.py$

  # Python type checking with Mypy
  - repo: https://github.com/pre-commit/mirrors-mypy
    rev: v1.8.0
    hooks:
      - id: mypy
        additional_dependencies: [types-all]
        files: \.py$

  # JavaScript/TypeScript with Prettier
  - repo: https://github.com/pre-commit/mirrors-prettier
    rev: v3.1.0
    hooks:
      - id: prettier
        files: \.(js|jsx|ts|tsx|json|css|md)$

  # JavaScript/TypeScript linting with ESLint
  - repo: https://github.com/pre-commit/mirrors-eslint
    rev: v8.56.0
    hooks:
      - id: eslint
        files: \.(js|jsx|ts|tsx)$
        additional_dependencies:
          - eslint-config-standard
          - eslint-plugin-react

  # Run project tests
  - repo: local
    hooks:
      - id: pytest
        name: pytest
        entry: pytest
        language: system
        pass_filenames: false
        always_run: true

Installez les hooks git :

pre-commit install

Maintenant vos hooks s’exécuteront automatiquement à chaque commit. Pour les exécuter manuellement sur tous les fichiers :

pre-commit run --all-files

Optimisation des performances des hooks

La vitesse compte—des hooks lents découragent les développeurs de commiter fréquemment. Suivez ces pratiques :

Exécutez les hooks uniquement sur les fichiers en stage : Le framework pre-commit fait cela par défaut, mais assurez-vous que vos hooks personnalisés respectent ce modèle.

Utilisez des outils rapides : Choisissez Ruff plutôt que Flake8 pour Python, ou Biome plutôt qu’ESLint pour JavaScript quand la vitesse est critique.

Évitez les vérifications coûteuses localement : Réservez les suites de tests complètes pour CI/CD. Les hooks locaux doivent se concentrer sur des gains rapides comme le formatage et le linting de base.

Parallélisez quand c’est possible : Certains outils supportent l’exécution parallèle. Par exemple, pytest peut exécuter des tests en parallèle avec pytest-xdist.

Bonnes pratiques d’adoption en équipe

Faire adopter les hooks pre-commit par votre équipe nécessite une implémentation réfléchie :

Commencez petit : Débutez avec des hooks non-intrusifs comme la suppression des espaces en fin de ligne. Ajoutez des vérifications plus strictes progressivement.

Documentez la configuration : Incluez les instructions d’installation dans votre README. Faites-en partie de votre processus d’intégration.

Gérez les différences d’environnement : Utilisez des hooks agnostiques au langage quand c’est possible. Pour les outils spécifiques à un langage, assurez-vous que votre .pre-commit-config.yaml spécifie des versions compatibles.

Fournissez des échappatoires : Parfois les développeurs ont besoin de contourner les hooks. Le flag --no-verify ignore tous les hooks :

git commit --no-verify -m "Emergency fix"

Utilisez ceci avec parcimonie et documentez quand c’est approprié.

Approches alternatives

Bien que pre-commit soit le framework le plus populaire, des alternatives existent :

Husky : Populaire dans les projets JavaScript, s’intègre bien avec les scripts npm.

Hooks Git natifs : Des scripts shell directs dans .git/hooks/ offrent un contrôle maximum mais manquent de portabilité.

Lefthook : Alternative rapide et multi-plateforme avec support d’exécution parallèle.

Pour la plupart des équipes, pre-commit offre le meilleur équilibre entre fonctionnalités, performance et support de l’écosystème.

Pièges courants et solutions

Échecs de hooks en CI : Assurez-vous que les environnements CI ont toutes les dépendances nécessaires installées. Considérez l’exécution de pre-commit run --all-files comme étape CI.

Problèmes spécifiques aux plateformes : Testez les hooks sur toutes les plateformes utilisées par votre équipe. Utilisez Docker pour des environnements cohérents si nécessaire.

Conflits de merge dans les fichiers de configuration : Gardez les modifications de .pre-commit-config.yaml minimales et atomiques. Mettez à jour les versions des hooks dans des commits séparés.

Conclusion

Les hooks pre-commit de Git transforment la qualité du code d’un processus réactif en processus proactif. En détectant les problèmes avant qu’ils n’entrent dans votre dépôt, vous économisez du temps, réduisez les changements de contexte et maintenez des standards plus élevés dans votre base de code. Commencez avec des hooks de formatage de base, ajoutez progressivement des linters et des vérificateurs de types, et priorisez toujours la vitesse pour maintenir le flux de travail de votre équipe fluide.

La clé d’une adoption réussie réside dans l’équilibre entre exhaustivité et expérience développeur. Des hooks rapides et ciblés qui apportent une valeur immédiate deviendront une partie indispensable du flux de travail de votre équipe.

FAQ

Gain control over your UX

See how users are using your site as if you were sitting next to them, learn and iterate faster with OpenReplay. — the open-source session replay tool for developers. Self-host it in minutes, and have complete control over your customer data. Check our GitHub repo and join the thousands of developers in our community.