Les plats clés

• Les crochets GIT sont des scripts simples qui s'exécutent avant ou après certaines actions, telles que les tests de syntaxe sur les fichiers engagés, et peuvent être écrits dans n'importe quelle langue avec laquelle l'environnement peut fonctionner.
• Deux types de crochets existent: c?té client, qui s'exécute sur le système du développeur, et c?té serveur, qui s'exécute sur le serveur hébergeant le référentiel GIT.
• Les crochets git ne sont pas distribués avec votre projet et ils ne peuvent pas être automatiquement installés, il est donc avantageux de créer un endroit pour que vos crochets vivent et disent à vos collaborateurs de les utiliser.
• Les crochets GIT sont un moyen puissant pour automatiser le flux de travail de votre projet, vous permettant de valider le code, de commettre des messages, de s'assurer que l'environnement est approprié, et plus encore.

Les crochets GIT sont des scripts simples qui s'exécutent avant ou après certaines actions. Ils sont utiles pour une variété de taches, mais je les trouve principalement utiles pour la validation c?té client afin que des erreurs simples puissent être évitées. Par exemple, vous pouvez tester la syntaxe sur les fichiers engagés, vous pouvez même faire fonctionner les tests. J'ai écrit des crochets qui valident la syntaxe Twig, exécutent Jshint à une norme, et bien plus encore.

git sont également extrêmement simples par conception. Git exécutera ces crochets si le script est exécutable et que Git permettra à l'action (par exemple, commegger ou push) se produire tant que le crochet sort sans erreurs (statut 0). Les crochets peuvent être écrits dans n'importe quelle langue avec laquelle l'environnement peut fonctionner.

Il existe deux types de crochets:

• c?té client - Ceux-ci fonctionnent sur le système du développeur
• c?té serveur - Ceux-ci s'exécutent sur le serveur hébergeant le référentiel git

Les crochets c?té serveur ne seront pas couverts dans cet article. Cependant, notez que si votre projet est sur un service comme GitHub, les crochets c?té serveur ne sont généralement pas applicables. Sur GitHub, l'équivalent aux crochets c?té serveur est d'utiliser des services et des webhooks qui peuvent être trouvés dans les paramètres de votre projet.

Les fichiers de crochet

Chaque référentiel comprenant ceux que vous clonez par défaut aura des exemples de crochets dans le répertoire .git / hooks:

<span>git clone git@github.com:symfony/symfony.git
</span><span>cd symfony
</span><span>ls .git/hooks</span>

Dans ce répertoire, vous verrez quelque chose comme:

applypatch-msg.sample
commit-msg.sample
post-update.sample
pre-applypatch.sample
pre-commit
pre-commit.sample
prepare-commit-msg.sample
pre-push.sample
pre-rebase.sample
update.sample

Nous nous concentrerons sur le crochet de pré-commit qui fonctionne avant d'autoriser une validation.

Un exemple de crochet: validation de la syntaxe PHP

Nous commencerons par un crochet très simple, écrit en bash, qui valide le code PHP engagé a une syntaxe valide. Il s'agit d'empêcher un engagement ?rapide? mais brisé de se produire. Bien s?r, je décourage les ?validations simples? qui ont peu ou pas de tests, mais cela ne signifie pas qu'ils ne se produiront pas.

Dans .Git / Hooks, nous pouvons démarrer un nouveau fichier appelé pré-engagement. Il doit avoir des autorisations à exécuter:

<span>git clone git@github.com:symfony/symfony.git
</span><span>cd symfony
</span><span>ls .git/hooks</span>

Vous pouvez utiliser votre éditeur préféré pour commencer à écrire. Nous avons d'abord besoin du shebang. Ma fa?on préférée est d'utiliser / usr / bin / env car cela utilise le chemin correct vers l'application que nous voulons plut?t qu'un chemin codé dur et éventuellement invalide. Pour l'instant, nous le verrons en continu afin que nous puissions facilement tester.

applypatch-msg.sample
commit-msg.sample
post-update.sample
pre-applypatch.sample
pre-commit
pre-commit.sample
prepare-commit-msg.sample
pre-push.sample
pre-rebase.sample
update.sample

PHP a une option utile pour la validation de la syntaxe: -l. Il faut un seul argument de fichier, nous devrons donc parcourir les fichiers PHP qui sont modifiés. Pour simplifier, nous supposerons que les fichiers PHP engagés se terminent toujours par .php. étant donné que le crochet est exécuté à partir de la racine du référentiel, nous pouvons utiliser des commandes GIT standard pour obtenir des informations sur les modifications, comme le statut GIT.

Au-dessus de la ligne #Always Fail, nous pouvons utiliser ce qui suit pour modifier tous les fichiers PHP:

<span>cd .git/hooks
</span><span>touch pre-commit
</span><span>chmod +x pre-commit</span>

Explication:

• php_files = dans Bash Affectation est effectué sans délimiteur, mais notez que la référence d'une variable nécessite le délimiteur $
• $ () est une syntaxe pour ?obtenir la sortie?. Les citations ne sont pas nécessaires pour l'utiliser.
• Grep est utilisé pour vérifier pour ajouter (a) et les fichiers modifiés (m)
• awk est utilisé ici pour imprimer $ 2. Un statut GIT complet - la ligne de short a un espace supplémentaire et des données supplémentaires au début, nous voulons donc supprimer cela. Awk effectue également un décapage automatique.
• Grep est à nouveau utilisé, mais il vérifie maintenant pour s'assurer que les lignes se terminent par .php

Maintenant, nous pouvons vérifier chaque fichier avec un pour une boucle:

<span>#!/usr/bin/env bash
</span><span># Hook that checks PHP syntax
</span>
<span># Override IFS so that spaces do not count as delimiters
</span><span>old_ifs=$IFS
</span><span><span>IFS</span>=$'<span title="\n">\n'</span>
</span>
<span># Always fail
</span><span>exit 1</span>

Cela peut sembler un peu étrange mais! php -l "$ i" (notez les devis pour éviter les problèmes avec les espaces) vérifie en fait une valeur de retour de 0, pas vrai ou l'un des types de valeurs que nous attendons normalement dans d'autres langues. Juste pour référence, le code PHP approximativement équivalent serait:

<span>php_files=<span>$(git status --short | grep -E '^(A|M)' | awk '{ print  }' | grep -E '\.php$')</span></span>

J'ai fait un mauvais changement pour Src / Symfony / Component / Finder / Glob.php exprès pour tester ceci et la sortie de Git Commit -M 'Test' est comme ?a:

<span>for file in $php_files; do
</span>  <span>if ! php -l "<span>$i"</span>; then
</span>    <span>exit 1
</span>  <span>fi
</span><span>done</span>

J'ai fait sortir la boucle tout le plus t?t possible et ce n'est peut-être pas ce que nous voulons. Nous pouvons en fait vouloir un résumé des choses à résoudre au lieu de devoir continuer à essayer de s'engager. Quiconque serait facilement frustré éventuellement et pourrait même apprendre à utiliser Git Commit - No-Verify pour contourner complètement le crochet.

Donc, à la place, ne sortons pas sur l'erreur avec PHP -L, mais je voudrais toujours garder les choses faciles à lire:

<span>foreach ($php_files as $file) {
</span>  <span>$retval = 0;
</span>  <span>$escapedFile = escapeshellarg($file);
</span>  <span>exec('php -l ' . $escapedFile, $retval); // $retval passed in as out parameter reference
</span>  <span>if ($retval !== 0) {
</span>    <span>exit(1);
</span>  <span>}
</span><span>}</span>

Ici, nous capturons la sortie pour PHP -L (et force la sortie d'erreur standard à la sortie standard). Nous vérifions l'état de sortie de PHP -L en utilisant la variable spéciale $? (qui est le code d'état de sortie) et l'opérateur -eq. Nous indiquons qu'une erreur de syntaxe s'est produite (notez l'utilisation de $ {} pour une variable dans une cha?ne). Enfin, nous donnons la ligne pertinente pour l'erreur pour garder la sortie un peu plus brève (greping for '^ analyse error'), et nous donnons une ligne vierge pour garder cela un peu plus lisible.

J'ai apporté deux mauvaises modifications et la sortie pour une tentative de validation ressemble à ceci:

<span>git clone git@github.com:symfony/symfony.git
</span><span>cd symfony
</span><span>ls .git/hooks</span>

Maintenant, le plan d'action consiste à résoudre ces problèmes, à tester et à essayer de s'engager à nouveau.

Pour terminer le script de crochet, supprimez la sortie 1 en bas du script. Essayez de commettre des fichiers PHP valides et cela devrait fonctionner comme d'habitude.

Partage des crochets

Les crochets ne sont pas distribués avec votre projet et ils ne peuvent pas être automatiquement installés. Ainsi, votre meilleur plan d'action est de créer un endroit pour que vos crochets vivent (pourraient être dans le même référentiel) et dire à vos collaborateurs de les utiliser. Si vous leur facilitez les choses, ils sont plus susceptibles de le faire.

Un moyen simple de le faire serait de créer un répertoire de crochets et un installateur simple-Hooks.sh.Sh qui les relie (plut?t que de copier):

applypatch-msg.sample
commit-msg.sample
post-update.sample
pre-applypatch.sample
pre-commit
pre-commit.sample
prepare-commit-msg.sample
pre-push.sample
pre-rebase.sample
update.sample

Quiconque clones de votre projet peut simplement exécuter Bash Install-Hooks.sh après le clonage.

Cela a également l'avantage de garder vos crochets sous le contr?le de la version.

Autres crochets

• Préparez-comit-MSG - Fournissez un message de validation par défaut si l'on n'est pas donné.
• commit-msg - validation des messages.
• Post-Commit - fonctionne après un engagement réussi.
• pré-poussoir - s'exécute avant que Git ne pousse après que la télécommande soit vérifiée pour fonctionner. Il faut 2 arguments: le nom de la télécommande et l'URL.
• PRE-REBASE - Exécute avant Git Rebase.
• post-vérification - fonctionne après un paiement réussi.
• Post-Merge - fonctionne après une fusion réussie.

Ces crochets fonctionnent généralement de la même manière que le pré-engagement bien qu'ils prennent des arguments. Un cas d'utilisation pour la post-vérification consiste à s'assurer qu'un fichier obtient toujours des autorisations appropriées (car GIT suit uniquement le lien exécutable, non exécutable et symbolique):

<span>cd .git/hooks
</span><span>touch pre-commit
</span><span>chmod +x pre-commit</span>

Pour commit-MSG, vous pouvez vous assurer que tous les messages de validation sont conformes à une norme, comme [subproject] Message . En voici un en php:

<span>#!/usr/bin/env bash
</span><span># Hook that checks PHP syntax
</span>
<span># Override IFS so that spaces do not count as delimiters
</span><span>old_ifs=$IFS
</span><span><span>IFS</span>=$'<span title="\n">\n'</span>
</span>
<span># Always fail
</span><span>exit 1</span>

Conclusion

Les crochets GIT sont un moyen puissant pour automatiser le flux de travail de votre projet. Vous pouvez valider le code, commettre des messages, vous assurer que l'environnement est approprié et bien plus encore. Y a-t-il quelque chose d'intéressant pour lequel vous utilisez des crochets Git? Faites-nous savoir dans les commentaires!

Questions fréquemment posées (FAQ) sur Git Hooks

Quels sont les différents types de crochets GIT?

Les crochets GIT sont divisés en deux types principaux: les crochets c?té client et c?té serveur. Les crochets c?té client sont déclenchés par des opérations telles que la validation et la fusion, tandis que les crochets c?té serveur s'exécutent sur les opérations réseau comme la réception des engins poussés. Chaque crochet peut être personnalisé pour répondre à vos besoins opérationnels spécifiques.

Comment créer un crochet git?

Pour créer un crochet git, accédez au répertoire .git / hooks dans votre référentiel. Ici, vous trouverez des exemples de scripts pour divers crochets. Pour créer un nouveau crochet, créez un fichier sans aucune extension (par exemple, pré-engagement), faites-le exécutable et écrivez votre script.

Comment puis-je utiliser des crochets GIT pour l'automatisation?

Les crochets GIT peuvent être utilisés pour automatiser une variété de taches dans votre flux de travail de développement. Par exemple, vous pouvez utiliser un crochet pré-engagé pour exécuter automatiquement des tests ou un linter sur votre code avant chaque validation. Cela garantit que seul le code testé et correctement formaté est engagé dans le référentiel.

Puis-je partager des crochets GIT avec mon équipe?

Par défaut, les crochets GIT ne sont pas inclus lorsque vous clonez un référentiel. En effet, ils sont stockés dans le répertoire .git, qui n'est pas versé. Cependant, vous pouvez les partager avec votre équipe en les stockant dans un répertoire séparé dans votre projet et en créant un script pour les symboliser en .git / hooks.

Comment puis-je utiliser Git Hooks pour appliquer les politiques?

Les crochets GIT peuvent être utilisés pour appliquer les politiques de projet ou d'entreprise. Par exemple, vous pouvez utiliser un crochet pré-récepteur sur le c?té du serveur pour rejeter toute poussée qui n'adhère pas à votre politique (par exemple, commet des engagements qui ne suivent pas un certain format).

Quelles langues Puis-je utiliser pour écrire des crochets git?

Les crochets GIT sont des scripts, vous pouvez donc les écrire dans n'importe quelle langue de script. Les échantillons par défaut sont écrits en bash, mais vous pouvez utiliser n'importe quelle langue avec laquelle vous êtes à l'aise, comme Python ou Ruby.

Puis-je utiliser des crochets Git pour intégrer avec d'autres outils?

Oui, oui, Les crochets GIT peuvent être utilisés pour intégrer GIT avec d'autres outils. Par exemple, vous pouvez utiliser un crochet post-Commit pour déclencher une version dans votre serveur d'intégration continue ou mettre à jour un billet dans votre système de suivi de l'émission.

Comment puis-je déboguer un crochet git?

Le débogage d'un crochet GIT peut être effectué en écrivant des informations dans un fichier à partir du script de crochet. Par exemple, vous pouvez rediriger la sortie des commandes vers un fichier journal pour l'inspecter plus tard.

Puis-je ignorer les crochets Git?

Oui, si vous souhaitez contourner un crochet Git tout en faisant un Commit, vous pouvez utiliser l'option –No-Verifier avec la commande git commit. Cela peut être utile lorsque vous travaillez sur un changement mineur qui ne nécessite pas les vérifications implémentées dans vos crochets.

Y a-t-il des risques associés à l'utilisation de crochets Git?

tandis que les crochets Git sont puissants, ils doivent être utilisés avec prudence. Un crochet mal écrit peut entra?ner des problèmes, notamment en rejetant tous les commits ou même la perte de données. Testez toujours vos crochets bien avant de les déployer.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!