Différence entre auteur et committer dans Git?

J’essaie de faire un commit comme

git commit --author="John Doe " -m "" 

où John Doe est un utilisateur au nom duquel je veux faire le commit.

Il apparaît bien dans git log . Cependant, lorsque je fais un gitk , le nom de l’auteur est correct, mais le nom du committer est choisi dans mes parameters globaux de configuration git (et est donc défini sur mon nom / email).

Des questions

  1. Quelle est la différence entre les deux (committer vs auteur)?

  2. Dois-je aussi régler le committer sur l’autre utilisateur?

  3. Si oui, comment?

L’affiche originale demande:

Quelle est la différence entre les deux (Committer vs auteur)?

L’auteur est la personne qui a initialement écrit le code. Le committer, d’autre part, est supposé être la personne qui a commis le code au nom de l’auteur original. Ceci est important dans Git, car Git vous permet de réécrire l’historique ou d’appliquer des correctifs au nom d’une autre personne. Le livre GRATUIT en ligne Pro Git explique:

Vous vous demandez peut-être quelle est la différence entre auteur et committer . L’ auteur est la personne qui a initialement écrit le patch, tandis que le committer est la dernière personne à avoir appliqué le patch. Donc, si vous envoyez un correctif à un projet et que l’un des membres principaux applique le correctif, vous obtenez tous les deux un crédit – vous en tant qu’auteur et le membre principal en tant que committer.

L’affiche originale demande:

Dois-je aussi régler le committer sur l’autre utilisateur?

Non, si vous voulez être honnête, vous ne devez pas placer le committer à l’auteur, à moins que l’auteur et le committer ne soient effectivement la même personne.

Liste de diffusion + git format-patch + git apply peut générer l’auteur! = Committer

Dans des projets comme le kernel Linux où les correctifs sont:

  • généré par git format-patch
  • envoyé par email, soit par collage, soit plus communément avec git send-email
  • appliqué par une autre personne avec soit git apply soit git am : comment utiliser git am pour appliquer des correctifs à partir de messages électroniques?

générer un nouveau commit avec un auteur et un committer différents:

  • l’auteur est qui a écrit le patch
  • le committer est qui est un mainteneur de projet et qui a fusionné le patch

Voir par exemple ce patch sélectionné au hasard et le commit correspondant:

Les interfaces Web Git comme GitHub et GitLab peuvent ou non générer l’auteur! = Committer

Étant donné que Git (Hub | Lab) contient à la fois les référentiels en amont et en aval sur le même ordinateur, ils peuvent faire automatiquement tout ce que vous pouvez faire localement, y compris:

  • Créez un commit de fusion.

    Ne génère pas d’auteur! = Committer.

    Conserve le SHA ou la nouvelle validation intacte et crée une nouvelle validation:

     * Merge commit (committer == author == project maintainer) |\ | * Feature commit (committer == author == consortingbutor) |/ * Old master (random committer and author) 

    Historiquement, c’était la première méthode disponible sur GitHub.

    Localement, cela se fait avec git merge --no-ff .

    Cela produit deux commits par requête de tirage, et garde une fourchette dans l’historique de git.

  • rebase sur le master

    GitHub pirate également les commits pour définir committer == quiconque a appuyé sur le bouton de fusion. Ce n’est pas obligatoire, et même par défaut, il n’est pas effectué localement par git rebase , mais il rend compte au responsable du projet.

    L’arbre git ressemble maintenant à:

     * Feature commit (committer == maintainer, author == consortingbutor) | * Old master (random committer and author) 

    qui est exactement comme celui des correctifs de messagerie git apply .

Sur GitHub actuellement:

  • vous choisissez la méthode lors de la fusion via la liste déroulante sur le bouton de fusion
  • les méthodes peuvent être activées ou désactivées sur les parameters du référentiel par le propriétaire

https://help.github.com/articles/about-merge-methods-on-github/

Comment définir le committer d’un nouveau commit?

Le mieux que j’ai pu trouver était d’utiliser les variables d’environnement pour remplacer le committer:

 GIT_COMMITTER_NAME='a' GIT_COMMITTER_EMAIL='a' git commit --author 'a ' 

Comment obtenir le committer et la date de validation d’un commit donné?

Seules les données de l’auteur s’affichent par défaut sur git log .

Pour voir la date d’embouteillage, vous pouvez soit:

  • formater le journal spécifiquement pour cela:

     git log --pretty='%cn %cd' -n1 HEAD 

    cn et cd représentent le Committer Name et la Committer Date

  • utilisez le format prédéfini fuller complet:

     git log --format=fuller 

    Voir aussi: Comment configurer ‘git log’ pour afficher ‘date de validation’

  • passer au niveau bas et afficher l’intégralité des données de validation:

     git cat-file -p HEAD 

Comment définir la date de mise en service d’un nouveau commit?

git commit --date ne définit que la date de l’auteur: pour la date du committer, le mieux que j’ai pu trouver était avec la variable d’environnement:

 GIT_COMMITTER_DATE='2000-01-01T00:00:00+0000' git commit --date='2000-01-01T00:00:00+0000' 

Voir aussi: Quelle est la différence entre auteur et committer dans Git?

Comment Git stocke-t-il l’auteur contre le committer en interne?

Voir: Quel est le format de fichier d’un object commit git?

Fondamentalement, le commit est un fichier texte et contient deux champs séparés par des lignes:

 author {author_name} <{author_email}> {author_date_seconds} {author_date_timezone} committer {committer_name} <{committer_email}> {committer_date_seconds} {committer_date_timezone} 

Cela montre clairement que les deux sont deux entrées de données complètement indépendantes dans l’object de validation.