Les crochets Git sont simples pour gérer votre référentiel

Git C'est un excellent outil. Il vous permet non seulement de suivre les modifications apportées à un fichier via des crochets, mais également de collaborer de manière transparente avec d'autres personnes. À cet égard, Git est l'un des outils qui a fait avancer le développement de FOSS. Cependant, l'un des plus gros problèmes avec Git est que la gestion de vos référentiels prend du temps et des efforts. Par exemple, l'exécution et la synchronisation de ces référentiels peuvent prendre deux à trois commandes git. Cela rend leur gestion non seulement fastidieuse, mais également sujette aux erreurs de l'utilisateur. Ici, nous vous montrons quelques crochets Git simples mais puissants pour mieux gérer vos référentiels.

Que sont les crochets Git ?

À la base, git-hook est une sous-commande flexible que vous pouvez utiliser pour créer des scripts personnalisés qui s'exécutent lorsque Git effectue une action sur le référentiel. Par exemple, il est possible d'utiliser hook pour vérifier automatiquement votre référentiel pour les erreurs de style avant de le valider.

La sous-commande hook fonctionne en lisant le dossier "hooks" sous le répertoire ".git" du référentiel. Ce dossier contient un certain nombre de fichiers prédéfinis qui fournissent un exemple de script pour chaque action Git que vous pouvez exécuter automatiquement.

Pour la plupart, vous pouvez écrire git hook dans n'importe quel langage de script que vous souhaitez. Cela le rend incroyablement flexible et accessible à tout développeur de logiciel.

1. Empêcher de pousser pour maîtriser

L'une des erreurs les plus courantes commises par un utilisateur dans Git est de pousser un commit de la branche de développement directement vers master. Cela peut être incroyablement frustrant si vous utilisez Github pour suivre et maintenir vos projets.

Vous pouvez éviter ce problème en créant un pré-push qui vérifiera et confirmera chaque fois que vous essayez de pousser un référentiel depuis la branche master.

1. Aller à Référentiel Git que vous souhaitez protéger.
2. Créer Fichier crochet Git à l'aide de votre correcteur de script. Étant donné que ce crochet doit être exécuté avant "Payer" , alors vous devez créer un crochet "prépayé":

   touchez .git/hooks/pre-push

3. Ouvert fichier crochet Nouveau dans éditeur de texte.

   nano .git/hooks/pre-push

4. A l'intérieur, écrivez crochet "avant paiement". Par exemple, voici un script qui vous demandera une confirmation lorsque vous pousserez depuis la branche master :

   #!/bin/sh protect='master' current=$(git symbolique-ref HEAD | sed -e 's,.*/\(.*\),\1,') if [ $protect = $current ] puis lisez -p "Confirmer l'envoi au maître ? O/n." -n 1 -r < /dev/tty echo if echo $REPLY | grep -E '^[Yy]$' > /dev/null then exit 0 fi exit 1 else exit 0 fi

5. Enregistrer nouveau crochet. dans un nano Faites-le en appuyant sur Ctrl + O , Alors Ctrl + X.
6. Exécutez la commande suivante pour vous assurer que Git peut exécuter le nouveau hook.

chmod +x .git/hooks/pre-push

2. Rejeter les push vers la branche principale

En plus de vous empêcher d'être poussé vers le maître, vous pouvez également créer un crochet côté serveur qui rejettera tout push vers sa branche maître. Ceci est extrêmement utile si vous partagez un référentiel avec plusieurs développeurs.

Corrigez cela en créant un crochet "pré-réception" qui empêchera automatiquement tout utilisateur restreint d'être poussé vers la branche principale.

1. Créer Fichier hook Git pour "pré-acquisition" dans votre entrepôt distant.

   touchez .git/hooks/pre-receive

2. Ouvrez cette déposer.

   nano .git/hooks/pré-réception

3. Ajouter un texte de refus dans crochet "reçu d'avance". Par exemple, les lignes de code suivantes devraient fonctionner immédiatement :

   #!/bin/sh branch=$(git réf-symbolique HEAD | sed -e 's,.*/\(.*\),\1,') blacklist=(alice bob) if [[ ${liste noire[ *]} =~ $UTILISATEUR ]] ; then if [ "$branch" == "master" ]; then echo "Vous n'êtes pas autorisé à valider les modifications dans cette branche" exit 1 fi fi

4. Enregistrez votre nouveau fichier hook. Dans mon cas, je dois appuyer sur Ctrl+O, puis Ctrl+X pour enregistrer le fichier.
5. Enregistrer crochet texte et le rendre exploitable.

chmod +x .git/hooks/pre-receive

Conseil : Vous pouvez également utiliser l'alias Git pour rendre votre utilisation de Git plus efficace.

3. Verrouillez le référentiel contre le rebasage

Une autre erreur courante commise par un utilisateur dans Git consiste à réinitialiser la branche actuellement active. Cela peut être un problème frustrant si vous travaillez sur un référentiel avec de nombreux contributeurs, car la refactorisation supprimera les validations faites par d'autres utilisateurs.

Vous pouvez éviter ce problème en créant un crochet "pré-rétablir" qui vérifiera si la branche actuelle est fermée ou non.

1. Créer fichier "pré-rebase" dans un répertoire ".git/hooks":

   touchez .git/hooks/pre-rebase

2. Ouvrez cette fichier à éditer.

   nano .git/hooks/pre-rebase

3. Ajouter le scénario rebasement À l'intérieur nouveau fichier crochet.

   #!/bin/sh branche="$2" [ -n "$branche" ] || branch=$(git rev-parse --abbrev-ref HEAD) lock="branch.${branch}.rebaselock" if [ "$(git config --bool "$lock")" = true ] ; then echo "hook pré-rebase : \"$lock\" est défini sur true. Refusing to rebase." sortie 1 fi

4. Enregistrer fichier crochet nouveau et le rendre exécutable.

chmod +x .git/hooks/pre-rebase

4. Forcez une vérification de style et de syntaxe sur votre code

L'une des utilisations les plus utiles de hook Git est de l'accrocher au code linter. Il s'agit d'un programme simple qui vérifie si votre code suit le style et le format du projet.

1. se rapporter linter à votre référentiel Git, créez d'abord un fichier hook "Engagement préalable".

   touchez .git/hooks/pre-commit

2. Installer linter adapté à la langue de votre projet. Dans ce cas, j'utilise "shellcheck" Pour analyser mon code Bash :

   sudo apt installer shellcheck

3. Ouvert fichier crochet new et ajoutez le script suivant.

   #!/bin/bash pour le fichier dans $(git diff --cached --name-only --diff-filter=AM | grep -E '\.sh$') do shellcheck "$file" # Exécuter le linter pour chaque nouveau fichier. si [ $ ? -ne 0 ] ; then exit 1 # Termine le commit si le linter échoue. fi fait

4. Enregistrer fichier crochet new et le rendre exécutable :

   chmod +x .git/hooks/pre-commit

5. Notifier automatiquement les utilisateurs des modifications apportées au référentiel

Enfin, vous pouvez également créer un crochet Git qui enverra automatiquement un e-mail chaque fois que votre référentiel recevra un nouveau commit. Ceci est utile si vous souhaitez créer un système de notification simple pour votre référentiel.

1. Créer fichier de crochets "post-récepteur" dans un répertoire .git / crochets dans votre entrepôt :

   touchez .git/hooks/post-receive

2. Ouvert Fichier crochet Git new et saisissez le script suivant :

   #!/bin/sh commit_message=$(git log -1 --pretty=%B) utilisateurs=("[email protected]""[email protected]""[email protected]”) pour l'utilisateur dans "${users[@]}" ; do mail -s "New Commit : $commit_message" $user < /dev/null done

3. Enregistrer fichier crochet nouveau et le rendre exécutable.

   chmod +x .git/hooks/post-réception

Questions en double

Q1. Puis-je écrire des crochets Git dans un langage compilé, tel que C ?

réponse. L'une des plus grandes limitations de Git Hooks est qu'il vous oblige à utiliser un langage que vous pouvez exécuter directement depuis le terminal. Cela signifie que les crochets Git ne prennent en charge aucune langue localisée pour leurs scripts. Par exemple, vous pouvez créer de nouveaux crochets Git en utilisant Python ou Shell et non C ou C++.

Q2. Est-il possible d'exécuter plusieurs crochets dans le même référentiel Git ?

réponse. Ouais. Alors que les exemples ci-dessus montrent les crochets comme des fonctionnalités individuelles distinctes, vous pouvez facilement les mélanger pour créer votre propre flux de travail unique, ce qui rend les crochets Git incroyablement flexibles et adaptables à toute situation de codage. Par exemple, vous pouvez utiliser à la fois le hook « Prevent Push to Master » et le crochet de précommit « Syntax Check » dans votre référentiel.

Q3 : Pourquoi les crochets Git n'envoient-ils pas d'e-mails aux utilisateurs ?

réponse. Ce problème est probablement dû au fait que votre serveur distant ne peut pas envoyer correctement les e-mails sortants. Pour résoudre ce problème, assurez-vous que votre serveur distant est sécurisé et dispose d'un agent de distribution de courrier fonctionnant conjointement avec un domaine SMTP.