Recherche…
Introduction
S'engager avec Git fournit la responsabilité en attribuant aux auteurs des modifications au code. Git offre de multiples fonctionnalités pour la spécificité et la sécurité des commits. Cette rubrique explique et démontre les bonnes pratiques et procédures lors de la validation avec Git.
Syntaxe
- git commit [drapeaux]
Paramètres
Paramètre | Détails |
---|---|
--message, -m | Message à inclure dans le commit. La spécification de ce paramètre contourne le comportement normal de Git d’ouvrir un éditeur. |
--modifier | Indiquez que les modifications en cours doivent être ajoutées (modifiées) à la validation précédente . Attention, cela peut réécrire l'histoire! |
--Pas de modification | Utilisez le message de validation sélectionné sans lancer un éditeur. Par exemple, git commit --amend --no-edit modifie un commit sans modifier son message de validation. |
--all, -a | Validez toutes les modifications, y compris celles qui ne sont pas encore mises en scène. |
--rendez-vous amoureux | Définissez manuellement la date qui sera associée à la validation. |
--seulement | Ne validez que les chemins spécifiés. Cela ne commettra pas ce que vous avez actuellement organisé sauf si vous y êtes invité. |
--patch, -p | Utilisez l'interface de sélection de correctifs interactive pour choisir les modifications à valider. |
--Aidez-moi | Affiche la page de manuel pour git commit |
-S [keyid], -S --gpg-sign [= keyid], -S --no-gpg-sign | Sign commit, validation du signe GPG, countermand commit.gpgSign variable de configuration |
-n, --no-verify | Cette option contourne les hooks pre-commit et commit-msg. Voir aussi les crochets |
S'engager sans ouvrir un éditeur
Git ouvre généralement un éditeur (comme vim
ou emacs
) lorsque vous lancez git commit
. Passez l'option -m
pour spécifier un message à partir de la ligne de commande:
git commit -m "Commit message here"
Votre message de validation peut dépasser plusieurs lignes:
git commit -m "Commit 'subject line' message here
More detailed description follows here (after a blank line)."
Vous pouvez également transmettre plusieurs arguments -m
:
git commit -m "Commit summary" -m "More detailed description follows here"
Voir Comment écrire un message Git Commit .
Guide de style de message Udacity Git Commit
Modifier un engagement
Si votre dernière validation n'est pas encore publiée (pas envoyée dans un référentiel en amont), vous pouvez modifier votre commit.
git commit --amend
Cela mettra les modifications en cours sur le commit précédent.
Remarque: Ceci peut également être utilisé pour modifier un message de validation incorrect. Il affichera l'éditeur par défaut (généralement vi
/ vim
/ emacs
) et vous permettra de modifier le message précédent.
Pour spécifier le message de validation en ligne:
git commit --amend -m "New commit message"
Ou utiliser le message de validation précédent sans le modifier:
git commit --amend --no-edit
La modification met à jour la date de validation mais laisse la date de l'auteur intacte. Vous pouvez dire à git de rafraîchir les informations.
git commit --amend --reset-author
Vous pouvez également changer l'auteur de la validation avec:
git commit --amend --author "New Author <[email protected]>"
Remarque: sachez que la modification de la validation la plus récente la remplace entièrement et que la validation précédente est supprimée de l'historique de la branche. Cela doit être pris en compte lorsque vous travaillez avec des référentiels publics et sur des succursales avec d’autres collaborateurs.
Cela signifie que si la validation précédente avait déjà été poussée, après modification, vous devrez push --force
.
Commettre des changements directement
Généralement, vous devez utiliser git add
ou git rm
pour ajouter des modifications à l'index avant de pouvoir les git commit
. Passez l'option -a
ou --all
pour ajouter automatiquement toutes les modifications (aux fichiers suivis) à l'index, y compris les suppressions:
git commit -a
Si vous souhaitez également ajouter un message de validation, procédez comme suit:
git commit -a -m "your commit message goes here"
Vous pouvez également joindre deux drapeaux:
git commit -am "your commit message goes here"
Vous n'avez pas nécessairement besoin de valider tous les fichiers à la fois. Ignorez l'indicateur -a
ou --all
et spécifiez le fichier que vous souhaitez valider directement:
git commit path/to/a/file -m "your commit message goes here"
Pour valider directement plusieurs fichiers spécifiques, vous pouvez également spécifier un ou plusieurs fichiers, répertoires et modèles:
git commit path/to/a/file path/to/a/folder/* path/to/b/file -m "your commit message goes here"
Créer un commit vide
En règle générale, les commits vides (ou validés avec un état identique au parent) constituent une erreur.
Cependant, lorsque vous testez des crochets de construction, des systèmes CI et d'autres systèmes qui déclenchent une validation, il est pratique de pouvoir créer facilement des validations sans avoir à modifier / toucher un fichier factice.
La --allow-empty
contournera la vérification.
git commit -m "This is a blank commit" --allow-empty
Stage et validation des modifications
Les bases
Après avoir modifié votre code source, vous devez mettre en place ces modifications avec Git avant de pouvoir les valider.
Par exemple, si vous modifiez README.md
et program.py
:
git add README.md program.py
Cela indique à git que vous voulez ajouter les fichiers à la prochaine validation que vous faites.
Ensuite, validez vos modifications avec
git commit
Notez que cela ouvrira un éditeur de texte, souvent vim . Si vous n'êtes pas familier avec vim, vous pouvez savoir que vous pouvez appuyer sur i
pour passer en mode insertion , écrire votre message de validation, puis appuyer sur Esc
et sur :wq
pour enregistrer et quitter. Pour éviter d'ouvrir l'éditeur de texte, incluez simplement le drapeau -m
avec votre message
git commit -m "Commit message here"
Les messages de validation suivent souvent des règles de formatage spécifiques, voir Bons messages de validation pour plus d'informations.
Raccourcis
Si vous avez changé beaucoup de fichiers dans le répertoire, plutôt que de les énumérer, vous pouvez utiliser:
git add --all # equivalent to "git add -a"
Ou pour ajouter toutes les modifications, à l' exception des fichiers supprimés , du répertoire et des sous-répertoires de niveau supérieur:
git add .
Ou pour ajouter uniquement des fichiers actuellement suivis ("update"):
git add -u
Si vous le souhaitez, passez en revue les modifications par étapes:
git status # display a list of changed files
git diff --cached # shows staged changes inside staged files
Enfin, validez les modifications:
git commit -m "Commit message here"
Alternativement, si vous avez seulement modifié des fichiers existants ou des fichiers supprimés, et que vous n'en avez pas créé de nouveaux, vous pouvez combiner les actions de git add
et git commit
dans une seule commande:
git commit -am "Commit message here"
Notez que ceci mettra en scène tous les fichiers modifiés de la même manière que git add --all
.
Données sensibles
Vous ne devez jamais commettre de données sensibles, telles que des mots de passe ou même des clés privées. Si ce cas se produit et que les modifications sont déjà transmises à un serveur central, considérez les données sensibles comme compromises. Sinon, il est possible de supprimer ces données par la suite. Une solution simple et rapide est l'utilisation du "BFG Repo-Cleaner": https://rtyley.github.io/bfg-repo-cleaner/ .
La commande bfg --replace-text passwords.txt my-repo.git
lit les mots de passwords.txt
fichier passwords.txt
et les remplace par ***REMOVED***
. Cette opération prend en compte tous les commits précédents du référentiel entier.
S'engager au nom de quelqu'un d'autre
Si quelqu'un a écrit le code que vous avez --author
, vous pouvez lui donner le crédit avec l'option --author
:
git commit -m "msg" --author "John Smith <[email protected]>"
Vous pouvez également fournir un modèle que Git utilisera pour rechercher les auteurs précédents:
git commit -m "msg" --author "John"
Dans ce cas, les informations sur l'auteur de la dernière validation avec un auteur contenant "John" seront utilisées.
Sur GitHub, les commits effectués de l'une des manières ci-dessus afficheront la vignette d'un grand auteur, avec le committer plus petit et devant:
Commettre des modifications dans des fichiers spécifiques
Vous pouvez valider les modifications apportées à des fichiers spécifiques et les ignorer à l'aide de git add
:
git commit file1.c file2.h
Ou vous pouvez d'abord mettre en scène les fichiers:
git add file1.c file2.h
et les commettre plus tard:
git commit
Bon commettre des messages
Il est important pour une personne parcourant le git log
de Git de comprendre facilement ce qu’est chaque validation. Les messages de validation corrects incluent généralement un numéro de tâche ou un problème dans un outil de suivi et une description concise de ce qui a été fait et pourquoi, et parfois aussi de la manière dont cela a été fait.
De meilleurs messages peuvent ressembler à:
TASK-123: Implement login through OAuth
TASK-124: Add auto minification of JS/CSS files
TASK-125: Fix minifier error when name > 200 chars
Considérant que les messages suivants ne seraient pas aussi utiles:
fix // What has been fixed?
just a bit of a change // What has changed?
TASK-371 // No description at all, reader will need to look at the tracker themselves for an explanation
Implemented IFoo in IBar // Why it was needed?
Une façon de tester si un message de validation est écrit dans le bon état d'esprit est de remplacer le blanc par le message et de voir si cela a du sens:
Si j'ajoute ce commit, je vais ___ dans mon référentiel.
Les sept règles d'un grand message de validation de git
- Séparer la ligne d'objet du corps avec une ligne vide
- Limite la ligne d'objet à 50 caractères
- Capitaliser la ligne d'objet
- Ne pas terminer la ligne d'objet avec un point
- Utilisez le caractère impératif dans la ligne d'objet
- Enroulez manuellement chaque ligne du corps à 72 caractères
- Utilisez le corps pour expliquer quoi et pourquoi plutôt que comment
7 règles du blog de Chris Beam .
S'engager à une date précise
git commit -m 'Fix UI bug' --date 2016-07-01
Le paramètre --date
définit la date de l' auteur . Cette date apparaîtra dans la sortie standard de git log
, par exemple.
Pour forcer la date de validation aussi:
GIT_COMMITTER_DATE=2016-07-01 git commit -m 'Fix UI bug' --date 2016-07-01
Le paramètre date accepte les formats flexibles pris en charge par la date GNU, par exemple:
git commit -m 'Fix UI bug' --date yesterday
git commit -m 'Fix UI bug' --date '3 days ago'
git commit -m 'Fix UI bug' --date '3 hours ago'
Lorsque la date ne spécifie pas l'heure, l'heure actuelle sera utilisée et seule la date sera remplacée.
Sélection des lignes à mettre en scène pour la validation
Supposons que vous ayez beaucoup de changements dans un ou plusieurs fichiers mais que, dans chaque fichier, vous ne souhaitez que commettre certaines des modifications, vous pouvez sélectionner les modifications souhaitées en utilisant:
git add -p
ou
git add -p [file]
Chacune de vos modifications sera affichée individuellement et pour chaque modification, vous serez invité à choisir l'une des options suivantes:
y - Yes, add this hunk
n - No, don’t add this hunk
d - No, don’t add this hunk, or any other remaining hunks for this file.
Useful if you’ve already added what you want to, and want to skip over the rest.
s - Split the hunk into smaller hunks, if possible
e - Manually edit the hunk. This is probably the most powerful option.
It will open the hunk in a text editor and you can edit it as needed.
Cela mettra en scène les parties des fichiers que vous choisissez. Ensuite, vous pouvez commettre toutes les modifications par étapes comme ceci:
git commit -m 'Commit Message'
Les modifications qui n'ont pas été transférées ou validées apparaîtront toujours dans vos fichiers de travail et pourront être validées ultérieurement si nécessaire. Ou si les modifications restantes sont indésirables, elles peuvent être supprimées avec:
git reset --hard
En plus de diviser un grand changement en de plus petits commits, cette approche est également utile pour examiner ce que vous êtes sur le point de commettre. En confirmant individuellement chaque modification, vous avez la possibilité de vérifier ce que vous avez écrit et d’éviter le transfert accidentel de code indésirable, tel que des instructions println / logging.
Modifier le temps d'un engagement
Vous modifiez le temps d'une validation en utilisant
git commit --amend --date="Thu Jul 28 11:30 2016 -0400"
ou même
git commit --amend --date="now"
Modifier l'auteur d'un commit
Si vous faites un commit en tant que mauvais auteur, vous pouvez le modifier, puis le modifier
git config user.name "Full Name"
git config user.email "[email protected]"
git commit --amend --reset-author
La signature GPG s'engage
Déterminez votre identifiant de clé
gpg --list-secret-keys --keyid-format LONG /Users/davidcondrey/.gnupg/secring.gpg -------------------------------------- sec 2048R/YOUR-16-DIGIT-KEY-ID YYYY-MM-DD [expires: YYYY-MM-DD]
Votre identifiant est un code alphanumérique à 16 chiffres après la première barre oblique.
Définissez votre identifiant de clé dans votre git config
git config --global user.signingkey YOUR-16-DIGIT-KEY-ID
Depuis la version 1.7.9, git commit accepte l'option -S pour attacher une signature à vos commits. L'utilisation de cette option vous demandera votre phrase de passe GPG et ajoutera votre signature au journal de validation.
git commit -S -m "Your commit message"