Différence entre l'auteur et le committer en Git?

liste de Diffusion + git format-patch + git apply peut générer de l'auteur != committer

dans des projets comme le noyau Linux où les correctifs sont:

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

de la génération d'un nouveau commit avec différents auteur et à valider:

• l'auteur est celui qui a écrit le patch
• le livreur est qui est un projet responsable, et qui a fusionné le patch

voir par exemple ce patch choisi au hasard et la propagation correspondante:

• https://lkml.org/lkml/2018/1/25/568
• https://github.com/torvalds/linux/commit/5beda7d54eafece4c974cfa9fbb9f60fb18fd20a

Git interfaces web comme GitHub et GitLab peut ou ne peut pas générer auteur != committer

puisque Git (Hub|Lab) tient à la fois les dépôts en amont et les dépôts à fourche sur une même machine, ils peut faire automatiquement tout ce que vous pouvez faire localement, y compris:

• Créer une fusion de la validation.

  ne génère pas d'auteur != committer.

  conserve le sha ou le nouveau commit intact, et crée un nouveau commit:

  * Merge commit (committer == author == project maintainer)
  |\
  | * Feature commit (committer == author == contributor)
  |/
  * 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 pull request, et garde une fourchette dans l'histoire git.

• rebase sur le dessus de la master

  GitHub pirate également les commits to set committer == quiconque a appuyé sur le bouton merge. Ce n'est pas obligatoire, et ce n'est même pas fait localement par défaut par git rebase , mais cela donne l'obligation de rendre compte au responsable du projet.

  Le git arbre ressemble maintenant à:

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

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

Sur GitHub actuellement:

• vous choisissez la méthode lors de la fusion via le menu déroulant sur le bouton de fusion
Les méthodes
• peuvent être activées ou désactivées par le propriétaire sur les paramètres de repo

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 outrepasser le committer:

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

Comment obtenir le committer et la date de commit d'une commit donnée?

seules les données de l'auteur apparaissent par défaut sur git log .

pour voir la date de committer vous pouvez soit:

• formatez le journal spécifiquement pour cela:

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

  où cn et cd signifient Committer Name et Committer Date

• utiliser le fuller format prédéfini:

  git log --format=fuller
  

  voir aussi: comment configurer 'git le journal' montrer 'commit date'

• aller de bas niveau et de montrer l'ensemble de commettre des données:

  git cat-file -p HEAD
  

comment définir la date du committer d'un nouveau commit?

git commit --date fixe seulement la date de l'auteur: pour la date du committer, le meilleur 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 auteur ou à valider en interne?

voir: Quel est le format de fichier d'un objet git commit?

fondamentalement, la propagation est un fichier texte, et il contient deux lignes séparées des champs:

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 des entrées de données complètement indépendantes dans l'objet commit.