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 tâches, 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.
Les crochetsgit 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:
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.
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.
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:
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.
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.
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>
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!
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.
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.
Les crochets GIT peuvent être utilisés pour automatiser une variété de tâches 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.
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.
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).
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.
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.
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.
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.
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!
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
