Git
S'engager

Introduction

Syntaxe

• git commit [drapeaux]

Paramètres

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

1. Séparer la ligne d'objet du corps avec une ligne vide
2. Limite la ligne d'objet à 50 caractères
3. Capitaliser la ligne d'objet
4. Ne pas terminer la ligne d'objet avec un point
5. Utilisez le caractère impératif dans la ligne d'objet
6. Enroulez manuellement chaque ligne du corps à 72 caractères
7. 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

1. 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.

2. Définissez votre identifiant de clé dans votre git config

   git config --global user.signingkey YOUR-16-DIGIT-KEY-ID
   

3. 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"